Pipeline

in this file we build a pipeline to

• load (local) fmnist csv dataset
• preprocess
  • normalize
  • convert to np
• and train an AE (simple conv, some casual architechture).

import tensorflow as tf
from tensorflow import keras
import pandas as pd
import numpy as np

from sklearn.preprocessing import Normalizer, MinMaxScaler, minmax_scale
from sklearn.pipeline import Pipeline

INFO:tensorflow:Enabling eager execution
INFO:tensorflow:Enabling v2 tensorshape
INFO:tensorflow:Enabling resource variables
INFO:tensorflow:Enabling tensor equality
INFO:tensorflow:Enabling control flow v2

import data

import csv as data frame (pandas) and convert to nparray

df_train = pd.read_csv('archive/fashion-mnist_train.csv') 
df_test = pd.read_csv('archive/fashion-mnist_test.csv')

separate labels X_train.pop pops specific features (original feature is deleted in X_train)

labels_train = df_train.pop('label')
labels_test = df_test.pop('label')
labels_name = {0: 't-Shirt/top',
    1: 'trousers',
    2: 'pullover',
    3: 'dress',
    4: 'coat',
    5: 'sandals',
    6: 'shirt',
    7: 'sneaker',
    8: 'bag',
    9: 'ankle boots'}

X_train = np.single(df_train).reshape(-1,28,28) / 255.
X_test = np.single(df_test).reshape(-1,28,28) / 255.

build AE

design AE as specific architecture right now: simple layer

from tensorflow.keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Flatten, Reshape, Conv2DTranspose
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import regularizers

input_img = Input(shape=(28,28,1))
regularizer = regularizers.l1(10e-5)
# model: encoder
encoded = Conv2D(32, (3, 3), activation='relu', 
                                padding='same')(input_img)
encoded = MaxPooling2D((2, 2), padding='same')(encoded)
encoded = Conv2D(16, (3, 3), activation='relu', 
                                padding='same')(encoded)
encoded = MaxPooling2D((2, 2), padding='same')(encoded)
encoded = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded)
encoded = Conv2D(4, (3, 3), activation='relu', padding='same')(encoded)
encoded = Flatten()(encoded)
#encoded = Dense(196, activation='relu')(encoded)
encoder = Model(input_img, encoded)

input_encoded = Input(shape=(196,))
encoder.summary()

Model: "model_10"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_5 (InputLayer)         [(None, 28, 28, 1)]       0         
_________________________________________________________________
conv2d_8 (Conv2D)            (None, 28, 28, 32)        320       
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 14, 14, 32)        0         
_________________________________________________________________
conv2d_9 (Conv2D)            (None, 14, 14, 16)        4624      
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 7, 7, 16)          0         
_________________________________________________________________
conv2d_10 (Conv2D)           (None, 7, 7, 8)           1160      
_________________________________________________________________
conv2d_11 (Conv2D)           (None, 7, 7, 4)           292       
_________________________________________________________________
flatten_2 (Flatten)          (None, 196)               0         
=================================================================
Total params: 6,396
Trainable params: 6,396
Non-trainable params: 0
_________________________________________________________________

# model: decoder
#decoded = Dense(392, activation='relu')(input_encoded)
decoded = Reshape((7,7,4))(input_encoded)
decoded = Conv2DTranspose(8, (3, 3), activation='relu', padding='same')(decoded)
decoded = Conv2DTranspose(16, (3, 3), activation='relu', padding='same')(decoded)
decoded = UpSampling2D((2, 2))(decoded)
decoded = Conv2DTranspose(32, (3, 3), activation='relu', 
                                padding='same')(decoded)
decoded = UpSampling2D((2, 2))(decoded)
decoded = Conv2DTranspose(1, (3, 3), activation='sigmoid', padding='same')(decoded)
decoder = Model(input_encoded, decoded)

decoder.summary()

Model: "model_11"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_6 (InputLayer)         [(None, 196)]             0         
_________________________________________________________________
reshape_3 (Reshape)          (None, 7, 7, 4)           0         
_________________________________________________________________
conv2d_transpose_12 (Conv2DT (None, 7, 7, 8)           296       
_________________________________________________________________
conv2d_transpose_13 (Conv2DT (None, 7, 7, 16)          1168      
_________________________________________________________________
up_sampling2d_6 (UpSampling2 (None, 14, 14, 16)        0         
_________________________________________________________________
conv2d_transpose_14 (Conv2DT (None, 14, 14, 32)        4640      
_________________________________________________________________
up_sampling2d_7 (UpSampling2 (None, 28, 28, 32)        0         
_________________________________________________________________
conv2d_transpose_15 (Conv2DT (None, 28, 28, 1)         289       
=================================================================
Total params: 6,393
Trainable params: 6,393
Non-trainable params: 0
_________________________________________________________________

# model: autoencoder (encoder + decoder)
encoded = encoder(input_img)
decoded = decoder(encoded)
autoencoder = Model(input_img, decoded)

optimizer = Adam(learning_rate=0.002)

loss = tf.keras.losses.BinaryCrossentropy();
autoencoder.compile(optimizer=optimizer, loss=loss)

#autoencoder.summary()

train AE

#from tensorflow.python.client import device_lib
#print(device_lib.list_local_devices())

early_stopping = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=3, min_delta=0.0003)
ckpt_filepath = 'model/fmnist_ae/checkpoints/fmnist_ae-ckpt'
checkpoint = tf.keras.callbacks.ModelCheckpoint(
    filepath=ckpt_filepath,
    save_weights_only=True,
    monitor='val_loss',
    save_best_only=True)
autoencoder.fit(X_train, X_train,
                epochs=50,
                batch_size=256,
                validation_data=(X_test, X_test),
                callbacks=[early_stopping],
                verbose=1)

Epoch 1/50
235/235 [==============================] - 4s 14ms/step - loss: 0.4202 - val_loss: 0.2933
Epoch 2/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2898 - val_loss: 0.2814
Epoch 3/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2825 - val_loss: 0.2780
Epoch 4/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2782 - val_loss: 0.2756
Epoch 5/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2756 - val_loss: 0.2746
Epoch 6/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2743 - val_loss: 0.2713
Epoch 7/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2732 - val_loss: 0.2696
Epoch 8/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2708 - val_loss: 0.2686
Epoch 9/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2707 - val_loss: 0.2689
Epoch 10/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2693 - val_loss: 0.2674
Epoch 11/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2687 - val_loss: 0.2672
Epoch 12/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2679 - val_loss: 0.2664
Epoch 13/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2665 - val_loss: 0.2653
Epoch 14/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2669 - val_loss: 0.2649
Epoch 15/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2667 - val_loss: 0.2653
Epoch 16/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2654 - val_loss: 0.2634
Epoch 17/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2649 - val_loss: 0.2631
Epoch 18/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2647 - val_loss: 0.2640
Epoch 19/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2638 - val_loss: 0.2622
Epoch 20/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2638 - val_loss: 0.2622
Epoch 21/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2638 - val_loss: 0.2614
Epoch 22/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2625 - val_loss: 0.2611
Epoch 23/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2630 - val_loss: 0.2624
Epoch 24/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2630 - val_loss: 0.2606
Epoch 25/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2615 - val_loss: 0.2604
Epoch 26/50
235/235 [==============================] - 3s 12ms/step - loss: 0.2618 - val_loss: 0.2601
Epoch 27/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2614 - val_loss: 0.2599
Epoch 28/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2615 - val_loss: 0.2599
Epoch 29/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2614 - val_loss: 0.2600
Epoch 30/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2612 - val_loss: 0.2601
Epoch 31/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2611 - val_loss: 0.2595
Epoch 32/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2603 - val_loss: 0.2590
Epoch 33/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2603 - val_loss: 0.2590
Epoch 34/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2601 - val_loss: 0.2589
Epoch 35/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2607 - val_loss: 0.2589
Epoch 36/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2601 - val_loss: 0.2595
Epoch 37/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2597 - val_loss: 0.2602
Epoch 38/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2598 - val_loss: 0.2585
Epoch 39/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2594 - val_loss: 0.2581
Epoch 40/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2591 - val_loss: 0.2585
Epoch 41/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2597 - val_loss: 0.2583
Epoch 42/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2592 - val_loss: 0.2575
Epoch 43/50
235/235 [==============================] - 2s 11ms/step - loss: 0.2587 - val_loss: 0.2576
Epoch 44/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2590 - val_loss: 0.2573
Epoch 45/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2591 - val_loss: 0.2574
Epoch 46/50
235/235 [==============================] - 3s 11ms/step - loss: 0.2593 - val_loss: 0.2572

<tensorflow.python.keras.callbacks.History at 0x1f67c699820>

save/load model

# save model
save_filepath = 'model/fmnist_ae/last'
autoencoder.save(
    filepath=save_filepath,
    overwrite=True,
    include_optimizer=True,
)

INFO:tensorflow:Assets written to: model/fmnist_ae/last\assets

# load model
save_filepath = 'model/fmnist_ae/last'
loaded_model = tf.keras.models.load_model(save_filepath)
autoencoder = loaded_model

input_img = autoencoder.input
encoded = autoencoder.layers[1].output
decoded = autoencoder.layers[2].output
encoder = Model(input_img, encoded)
decoder = Model(autoencoder.layers[2].input, decoded)

show result

encoded_imgs = encoder.predict(X_test)
decoded_imgs = decoder.predict(encoded_imgs)

import matplotlib.pyplot as plt

categorize by labels/categories

decoded_imgs_classified=np.zeros((10,1000,28,28))
original_imgs_classified=np.zeros((10,1000,28,28))
for i in range(10): # it should be better this way if each category has the same number of items
    decoded_imgs_classified[i,:,:,:] = decoded_imgs[labels_test==i].reshape(-1,28,28)
    original_imgs_classified[i,:,:,:] = X_test[labels_test==i].reshape(-1,28,28)

10 classes

n = 10  # how many images we will display
plt.figure(figsize=(20, 4))
for i in range(n):
    # display original
    ax = plt.subplot(2, n, i + 1)
    plt.imshow(original_imgs_classified[i,0])
    plt.gray()
    ax.set_xticks([])
    ax.set_yticks([])

    # display reconstruction
    ax = plt.subplot(2, n, i + 1 + n)
    plt.imshow(decoded_imgs_classified[i,0])
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_xlabel(labels_name[i])
plt.savefig('images/fmnist_ae/fmnist_reconstructed_all.png', dpi=120)
plt.show()

1 class

n = 10  # how many images we will display
fig = plt.figure(figsize=(20, 4))
selected_class = 0 # the class to be shown
for i in range(n):
    # display original
    ax = fig.add_subplot(2, n, i + 1)
    plt.imshow(original_imgs_classified[selected_class,i])
    plt.gray()
    ax.set_xticks([])
    ax.set_yticks([])

    # display reconstruction
    ax = fig.add_subplot(2, n, i + 1 + n)
    plt.imshow(decoded_imgs_classified[selected_class,i])
    plt.gray()
    ax.set_xticks([])
    ax.set_yticks([])

fig.suptitle(labels_name[selected_class])
plt.savefig('images/fmnist_ae/fmnist_reconstructed_'+str(selected_class)+'.png', dpi=120)
plt.show()

loss for each class

bce = tf.keras.losses.BinaryCrossentropy();
mse = tf.keras.losses.MeanSquaredError();
loss_test = np.zeros(10)
input_entropy = np.zeros(10)
for i in range(10):
    loss_test[i] = bce(original_imgs_classified[i].reshape(-1,28*28),
        decoded_imgs_classified[i].reshape(-1,28*28)).numpy()
    input_entropy[i] = bce(original_imgs_classified[i].reshape(-1,28*28),
        original_imgs_classified[i].reshape(-1,28*28)).numpy()

fig = plt.figure(figsize=(10,7.5))
ax = fig.add_subplot(111)

bce_bar = ax.bar(range(10),loss_test)
e_line, = ax.plot(range(10),input_entropy, 'r+-')
ax.set_xticks(range(10))
ax.set_xticklabels(labels_name.values())

#ax.set_ylabel(ylabel='Binary Cross Entropy', fontsize=15)
ax.set_ylim((0,.45))

bce_bar.set_label('Binary Cross Entropy')
e_line.set_label('Binary Entropy of Input')
ax.legend(loc='upper right',
    fontsize='large')

ax.tick_params(labelsize=15)
ax.set_title('CIFAR10', fontsize=18)

fig.autofmt_xdate()

plt.savefig('images/fmnist_ae/fmnist_ae_bce.png',dpi=120)
plt.show()

t-SNE visualization

from sklearn.manifold import TSNE

latent_manifold = TSNE(n_components=3, random_state=33)
latent_points = latent_manifold.fit_transform(encoded_imgs) # doesn't work for 7,7,4 only works with 7,7,<=2

plt.figure(figsize=(10, 5))
plt.scatter(latent_points[:, 0], 
    latent_points[:, 1], 
    #s=10,
    c=labels_test, 
    cmap='Paired',
    label="t-SNE")
plt.savefig('images/fmnist_ae/fmnist_tsne.png', dpi=120)
plt.show()

UMAP visualization

import umap
import umap.plot

mapper = umap.UMAP().fit(encoded_imgs)

umap.plot.points(mapper, labels=labels_test, color_key_cmap='Paired', background='black')

<AxesSubplot:>

plt.figure(figsize=(10, 5))
plt.scatter(mapper.embedding_[:, 0], 
    mapper.embedding_[:, 1], 
    c=labels_test, 
    cmap='Paired',
    label="t-SNE")
plt.savefig('images/fmnist_ae/fmnist_umap.png', dpi=120)
plt.show()